home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / ste / autoexec.lzh / SOURCE / AUTOEXEC.C next >
C/C++ Source or Header  |  1991-08-05  |  5KB  |  231 lines
  1. #include <tos.h>
  2.  
  3. #include "mxalloc.h"
  4. #include "player.h" 
  5. #include "header.h"
  6.  
  7.  
  8. #define AUTO_NAME "autoexec.sys"
  9.  
  10.  
  11. /* default free memory, below the sound sample */
  12. static long keep_free = 100000l; 
  13.  
  14. /* flag that tells if a sound sample is loaded */
  15. static int sound_loaded = 0;
  16.  
  17. /* copy of bit 1 (DMA) in the sound cookie */
  18. static int DMAsound = 0;
  19.  
  20. /* empty command line, for use when starting programs */
  21. const COMMAND empty_command = {0,""};
  22.  
  23. /* the most resent pressed key */
  24. static char CurrentKey = 0;
  25.  
  26. /* default key flag (don't wait on keypress) */
  27. static int DefaultKey = 0;
  28.  
  29.  
  30. long atol(char *s)
  31. /* me own StringToLong routine, using TC's costed 1 Kbyte !!! */
  32. {int n;
  33.  long l;
  34.  
  35.     l = 0;
  36.     while (*s)
  37.     {    n = *s++ - '0';
  38.         if (n>=0 && n<=9)
  39.             l = 10*l + n;
  40.         else
  41.             break;
  42.     }
  43.     return l;
  44. } 
  45.  
  46.  
  47. int execute_line(char *line)
  48. {int file, segm_repeat, no_exec;
  49.  long length;
  50.  char *tmp;
  51.     
  52.     no_exec = 0;
  53.     if (*line == '?') /* is it a conditional instruction ? */
  54.     {    no_exec = 1; /* if condition, then assume don't execute */
  55.         do
  56.         {    if (*++line == CurrentKey) /* condition true ? */
  57.                 no_exec = 0; /* ok, then execute rest of line... */
  58.             ++line;
  59.         } while (*line == '?'); /* is it still a conditional ? */
  60.     }
  61.     
  62.     if (no_exec) 
  63.         return 0;
  64.         
  65.     switch (*line++)
  66.     {    case 'X': /* break instruction execution */
  67.             return 1;
  68.             
  69.         case 'W': /* print a string and Wait for keyboard input */
  70.             Cconws(line);
  71.             if (!DefaultKey || Cconis())
  72.                 /* If there is a Key waiting in the keyboard buffer
  73.                  * OR there is no default key - then read key from buffer 
  74.                  */
  75.                 CurrentKey = (char)(Cconin() & 0xff);
  76.             Cconws("\r\n");
  77.             DefaultKey = 0;            
  78.             break;
  79.  
  80.         case 'P': /* print a string */
  81.             Cconws(line);
  82.             Cconws("\r\n");
  83.             break;
  84.             
  85.         case 'D': /* set default key for the next 'wait for key' */
  86.             DefaultKey = 1;
  87.             CurrentKey = *line;
  88.             break;
  89.             
  90.         case '>': /* start sound sample */
  91.             if (!DMAsound)
  92.                 break;
  93.             if (sound_loaded)
  94.             {    STe_end(0);
  95.                 sound_loaded = 0;
  96.             }
  97.             
  98.             if ( (file = Fopen(line, 0)) <= 0 )
  99.                 goto sn_err;
  100.  
  101.             length = Fseek(0, file, 2);
  102.             Fseek(0, file, 0);
  103.             
  104.             /* allocate memory for the 'free' section and the sound.
  105.              *    this way we don't put a sample where somone else expects
  106.              *    code or data...
  107.              */    
  108.             if ((tmp = Mxalloc(length+keep_free, MX_STON)) > 0l)
  109.             {    if (!LoadSegm(file, &segm_repeat, length, 
  110.                     (long *)tmp + keep_free))
  111.                 {    SetPlayFreq(PlayFreq);
  112.                     STe_segment((long *)tmp + keep_free, segm_repeat);
  113.                     sound_loaded = 1;
  114.                 }
  115.                 /* now free the memory, hoping that no one else allocate
  116.                  * it!!
  117.                  */            
  118.                 Mfree(tmp);
  119.             }
  120.             Fclose(file);
  121.             
  122.             if (!sound_loaded)
  123.                 goto sn_err;
  124.             break;
  125.  
  126.         case '#': /* set free memory, below samples */
  127.             keep_free = atol(line); 
  128.             break;
  129.             
  130.         case '!': /* execute program */
  131.             if (Pexec(0, line, &empty_command, 0l) < 0)
  132.                 goto ex_err;
  133.             break;
  134.             
  135.         default:;
  136.     }
  137.     return 0;
  138.     
  139. sn_err:
  140.     Cconws("AUTO: can't play the file: ");
  141.     goto w_name;
  142. ex_err:
  143.     Cconws("AUTO: Can't execute the file: ");
  144. w_name:
  145.     Cconws(line);
  146.     Cconws("\r\n");
  147.     
  148. NoLoad:
  149.     return 0;
  150. }
  151.  
  152.  
  153. main()
  154. {int file, store_line, skip_remaining;
  155.  long length, lines, l, snd;
  156.  char *p, *file_buffer;
  157.  char **line_buffer;
  158.     
  159.     /* turn on the cursor */
  160.     Cursconf(1, 0);
  161.     
  162.     /* check if the computer have DMA sound */
  163.     if (get_cookie('_SND', &snd) && (snd & 2)) /* DMA sound? */
  164.         DMAsound = 1;
  165.  
  166.     /* read the AUTO file into memory */
  167.     if ((file = Fopen(AUTO_NAME,0)) < 0)
  168.         goto op_err;
  169.     length = Fseek(0l,file,2);
  170.     Fseek(0l,file,0);
  171.     file_buffer = Mxalloc(length,MX_TTPR);
  172.     Fread(file,length,file_buffer);
  173.     Fclose(file);
  174.     
  175.     /* calculate an estimate of the number of lines */
  176.     p = file_buffer;
  177.     lines = 0;
  178.     for(l=0; l<length; l++)
  179.         if (*p++ == '\n')
  180.             lines += 4;
  181.     
  182.     line_buffer = Mxalloc(lines,MX_TTPR);
  183.     
  184.     /* now put pointers to each line into the lines array */
  185.     p = file_buffer;
  186.     store_line = 1;
  187.     skip_remaining = 0;
  188.     lines = 0;
  189.     for(l=0; l<length; l++)
  190.     {    if (*p == ';') /* comment */
  191.         {    skip_remaining = 1;
  192.             *p = '\0';
  193.         }
  194.  
  195.         /* is it a command line ? */
  196.         if (*p > ' ' && store_line && !skip_remaining)
  197.         {    line_buffer[lines++] = p;
  198.             store_line = 0;
  199.         }
  200.  
  201.         if (*p == '\n' || *p == '\r') /* end of line */
  202.         {    *p = '\0';
  203.             store_line = 1;
  204.             skip_remaining = 0;
  205.         }
  206.         ++p;
  207.     }
  208.     
  209.     /* execute each line in the file. */
  210.     l = 0;
  211.     while (lines--)
  212.         if (execute_line(line_buffer[l++]))
  213.             /* stop executing if execute_line() returns 1 */
  214.             break;
  215.     
  216.     if (sound_loaded)
  217.         STe_end(1);
  218.  
  219.     /* clean up, and return */
  220.     Mfree(line_buffer);
  221.     Mfree(file_buffer);
  222.  
  223.     return 0;
  224.  
  225. op_err:
  226.     Cconws(
  227.         "AUTO: can't open \"" 
  228.         AUTO_NAME
  229.         "\" for input!\r\n"); 
  230.     return 0;
  231. }